home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / mui / MCC_Lamp.lha / MCC_Lamp / Developer / C / Examples / Lamp-Demo.c next >
C/C++ Source or Header  |  1997-03-15  |  26KB  |  726 lines
  1.  
  2. #include <exec/types.h>
  3. #if defined __MAXON__ || defined __STORM__
  4. #include <pragma/exec_lib.h>
  5. #else
  6. #include <proto/exec.h>
  7. #endif
  8. #include <exec/libraries.h>
  9. #if defined __MAXON__ || defined __STORM__
  10. #include <pragma/muimaster_lib.h>
  11. #else
  12. #include <proto/muimaster.h>
  13. #endif
  14. #include <libraries/mui.h>
  15. #if defined __MAXON__ || defined __STORM__
  16. #include <pragma/intuition_lib.h>
  17. #else
  18. #include <proto/intuition.h>
  19. #endif
  20. #include <intuition/classusr.h>
  21. #include <dos/dos.h>
  22. #include <clib/alib_protos.h>
  23. #include <string.h>
  24. #include <stdlib.h>
  25. #if defined __MAXON__ || defined __STORM__
  26. #include <wbstartup.h>
  27. #endif
  28.  
  29. #include <mui/Lamp_mcc.h>
  30.  
  31.  
  32. /* copied from <blizzy/macros.h> */
  33. #ifndef REG
  34. #ifdef _DCC
  35. #define REG(x) __ ## x
  36. #else
  37. #define REG(x) register __ ## x
  38. #endif
  39. #endif
  40.  
  41. #ifndef ASM
  42. #if defined __MAXON__ || defined __STORM__ || defined _DCC
  43. #define ASM
  44. #else
  45. #define ASM __asm
  46. #endif
  47. #endif
  48.  
  49. #ifndef SAVEDS
  50. #ifdef __MAXON__
  51. #define SAVEDS
  52. #endif
  53. #if defined __STORM__ || defined __SASC
  54. #define SAVEDS __saveds
  55. #endif
  56. #if defined _GCC || defined _DCC
  57. #define SAVEDS __geta4
  58. #endif
  59. #endif
  60.  
  61.  
  62. #define DropableLampObject NewObject(clDropableLamp->mcc_Class, NULL
  63.  
  64. struct DropableLampData
  65. {
  66.   ULONG dummy;
  67. };
  68.  
  69.  
  70. #define BlinkingLampObject NewObject(clBlinkingLamp->mcc_Class, NULL
  71.  
  72. #define MUIM_BlinkingLamp_Blink 0x85b9ffff
  73.  
  74. struct BlinkingLampData
  75. {
  76.   struct MUI_InputHandlerNode ihn;
  77.   BOOL                        black;
  78. };
  79.  
  80.  
  81. #define TrafficLightObject NewObject(clTrafficLight->mcc_Class, NULL
  82.  
  83. #define MUIM_TrafficLight_Change 0x85b9fffe
  84.  
  85. struct TrafficLightData
  86. {
  87.   Object                      *lpLampRed;
  88.   Object                      *lpLampYellow;
  89.   Object                      *lpLampGreen;
  90.   struct MUI_InputHandlerNode  ihn;
  91.   UBYTE                        state;
  92. };
  93.  
  94.  
  95. #define GUI_LAMP_COLORTYPE 1
  96.  
  97.  
  98. Object                 *apMain         = NULL;
  99. Object                 *  wiMain;
  100. Object                 *    lpLamp;
  101. Object                 *    caColor;
  102. Object                 *    btTiny;
  103. Object                 *    btSmall;
  104. Object                 *    btMedium;
  105. Object                 *    btBig;
  106. Object                 *    btHuge;
  107. Object                 *    btColorOff;
  108. Object                 *    btColorOk;
  109. Object                 *    btColorWarning;
  110. Object                 *    btColorError;
  111. Object                 *    btColorFatalError;
  112. Object                 *    btColorProcessing;
  113. Object                 *    btColorLookingUp;
  114. Object                 *    btColorConnecting;
  115. Object                 *    btColorSendingData;
  116. Object                 *    btColorReceivingData;
  117. Object                 *    btColorLoadingData;
  118. Object                 *    btColorSavingData;
  119. Object                 *    pdShine;
  120. Object                 *    pdHalfShine;
  121. Object                 *    pdBackground;
  122. Object                 *    pdHalfShadow;
  123. Object                 *    pdShadow;
  124. Object                 *    pdText;
  125. Object                 *    pdFill;
  126. Object                 *    pdMark;
  127. Object                 *    txColorType;
  128.  
  129. struct MUI_CustomClass *clDropableLamp = NULL;
  130. struct MUI_CustomClass *clBlinkingLamp = NULL;
  131. struct MUI_CustomClass *clTrafficLight = NULL;
  132.  
  133. struct Library         *MUIMasterBase  = NULL;
  134.  
  135.  
  136. ULONG DoSuperNew(struct IClass *cl, Object *obj, ULONG tag1, ...)
  137. {
  138.   return(DoSuperMethod(cl, obj, OM_NEW, &tag1, NULL));
  139. }
  140.  
  141. ULONG DropableLamp_DragDrop(Object *obj, struct MUIP_DragDrop *msg)
  142. {
  143.   struct MUI_PenSpec *penspec;
  144.  
  145.   get(msg->obj, MUIA_Pendisplay_Spec, &penspec);
  146.   set(obj, MUIA_Lamp_PenSpec, penspec);
  147.  
  148.   return(0);
  149. }
  150. ULONG ASM SAVEDS DropableLamp_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  151. {
  152.   switch (msg->MethodID)
  153.   {
  154.     case MUIM_DragQuery: return(MUIV_DragQuery_Accept);
  155.     case MUIM_DragDrop:  return(DropableLamp_DragDrop(obj, (struct MUIP_DragDrop *) msg));
  156.   }
  157.   return(DoSuperMethodA(cl, obj, msg));
  158. }
  159.  
  160. ULONG BlinkingLamp_Setup(struct IClass *cl, Object *obj, Msg msg)
  161. {
  162.   if (!DoSuperMethodA(cl, obj, msg))
  163.     return(FALSE);
  164.   {
  165.     struct BlinkingLampData *data = INST_DATA(cl, obj);
  166.  
  167.     memset(data, 0, sizeof(struct BlinkingLampData));
  168.  
  169.     DoMethod(obj, MUIM_Lamp_SetRGB, 0, 0, 0);
  170.     data->black = TRUE;
  171.  
  172.     data->ihn.ihn_Object = obj;
  173.     data->ihn.ihn_Method = MUIM_BlinkingLamp_Blink;
  174.     data->ihn.ihn_Flags  = MUIIHNF_TIMER;
  175.     {
  176.       static UWORD millis = 50;
  177.  
  178.       data->ihn.ihn_Millis = millis;
  179.       millis += 32;
  180.     }
  181.     DoMethod(_app(obj), MUIM_Application_AddInputHandler, &data->ihn);
  182.   }
  183.   return(TRUE);
  184. }
  185. ULONG BlinkingLamp_Cleanup(struct IClass *cl, Object *obj, Msg msg)
  186. {
  187.   struct BlinkingLampData *data = INST_DATA(cl, obj);
  188.  
  189.   DoMethod(_app(obj), MUIM_Application_RemInputHandler, &data->ihn);
  190.  
  191.   return(DoSuperMethodA(cl, obj, msg));
  192. }
  193. ULONG BlinkingLamp_Blink(struct IClass *cl, Object *obj)
  194. {
  195.   struct BlinkingLampData *data = INST_DATA(cl, obj);
  196.  
  197.   if (data->black)
  198.   {
  199.     set(obj, MUIA_Lamp_Color, MUIV_Lamp_Color_FatalError);
  200.     data->black = FALSE;
  201.   }
  202.   else
  203.   {
  204.     DoMethod(obj, MUIM_Lamp_SetRGB, 0, 0, 0);
  205.     data->black = TRUE;
  206.   }
  207.   return(TRUE);
  208. }
  209. ULONG ASM SAVEDS BlinkingLamp_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  210. {
  211.   switch (msg->MethodID)
  212.   {
  213.     case MUIM_Setup:              return(BlinkingLamp_Setup(cl, obj, msg));
  214.     case MUIM_Cleanup:            return(BlinkingLamp_Cleanup(cl, obj, msg));
  215.  
  216.     case MUIM_BlinkingLamp_Blink: return(BlinkingLamp_Blink(cl, obj));
  217.   }
  218.   return(DoSuperMethodA(cl, obj, msg));
  219. }
  220.  
  221. ULONG TrafficLight_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  222. {
  223.   Object *lpLampRed;
  224.   Object *lpLampYellow;
  225.   Object *lpLampGreen;
  226.  
  227.   if (obj = (Object *) DoSuperNew(cl, obj,
  228.     MUIA_Group_VertSpacing, 1,
  229.     Child, lpLampRed    = LampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Huge, End,
  230.     Child, lpLampYellow = LampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Huge, End,
  231.     Child, lpLampGreen  = LampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Huge, End,
  232.     TAG_MORE, msg->ops_AttrList))
  233.   {
  234.     struct TrafficLightData *data = INST_DATA(cl, obj);
  235.  
  236.     memset(data, 0, sizeof(struct TrafficLightData));
  237.  
  238.     data->lpLampRed    = lpLampRed;
  239.     data->lpLampYellow = lpLampYellow;
  240.     data->lpLampGreen  = lpLampGreen;
  241.  
  242.     return((ULONG) obj);
  243.   }
  244.   return(0);
  245. }
  246. ULONG TrafficLight_Setup(struct IClass *cl, Object *obj, Msg msg)
  247. {
  248.   if (!DoSuperMethodA(cl, obj, msg))
  249.     return(FALSE);
  250.   {
  251.     struct TrafficLightData *data = INST_DATA(cl, obj);
  252.  
  253.     DoMethod(data->lpLampRed,    MUIM_Lamp_SetRGB, 0xffffffff, 0, 0);
  254.     DoMethod(data->lpLampYellow, MUIM_Lamp_SetRGB, 0,          0, 0);
  255.     DoMethod(data->lpLampGreen,  MUIM_Lamp_SetRGB, 0,          0, 0);
  256.     data->state = 0;
  257.  
  258.     memset(&data->ihn, 0, sizeof(struct MUI_InputHandlerNode));
  259.     data->ihn.ihn_Object = obj;
  260.     data->ihn.ihn_Method = MUIM_TrafficLight_Change;
  261.     data->ihn.ihn_Flags  = MUIIHNF_TIMER;
  262.     data->ihn.ihn_Millis = 7500;
  263.     DoMethod(_app(obj), MUIM_Application_AddInputHandler, &data->ihn);
  264.   }
  265.   return(TRUE);
  266. }
  267. ULONG TrafficLight_Cleanup(struct IClass *cl, Object *obj, Msg msg)
  268. {
  269.   struct TrafficLightData *data = INST_DATA(cl, obj);
  270.  
  271.   DoMethod(_app(obj), MUIM_Application_RemInputHandler, &data->ihn);
  272.  
  273.   return(DoSuperMethodA(cl, obj, msg));
  274. }
  275. ULONG TrafficLight_Change(struct IClass *cl, Object *obj)
  276. {
  277.   struct TrafficLightData *data = INST_DATA(cl, obj);
  278.   Object                  *app;
  279.  
  280.   get(obj, MUIA_ApplicationObject, &app);
  281.  
  282.   DoMethod(app, MUIM_Application_RemInputHandler, &data->ihn);
  283.  
  284.   memset(&data->ihn, 0, sizeof(struct MUI_InputHandlerNode));
  285.   data->ihn.ihn_Object = obj;
  286.   data->ihn.ihn_Method = MUIM_TrafficLight_Change;
  287.   data->ihn.ihn_Flags  = MUIIHNF_TIMER;
  288.  
  289.   switch (data->state)
  290.   {
  291.     case 0:
  292.       DoMethod(data->lpLampYellow, MUIM_Lamp_SetRGB, 0xffffffff, 0xffffffff, 0);
  293.       data->ihn.ihn_Millis = 1500;
  294.       data->state = 1;
  295.       break;
  296.     case 1:
  297.       DoMethod(data->lpLampRed,    MUIM_Lamp_SetRGB, 0, 0,          0);
  298.       DoMethod(data->lpLampYellow, MUIM_Lamp_SetRGB, 0, 0,          0);
  299.       DoMethod(data->lpLampGreen,  MUIM_Lamp_SetRGB, 0, 0xffffffff, 0);
  300.       data->ihn.ihn_Millis = 7500;
  301.       data->state = 2;
  302.       break;
  303.     case 2:
  304.       DoMethod(data->lpLampGreen,  MUIM_Lamp_SetRGB, 0,          0,          0);
  305.       DoMethod(data->lpLampYellow, MUIM_Lamp_SetRGB, 0xffffffff, 0xffffffff, 0);
  306.       data->ihn.ihn_Millis = 1500;
  307.       data->state = 3;
  308.       break;
  309.     case 3:
  310.       DoMethod(data->lpLampYellow, MUIM_Lamp_SetRGB, 0,          0, 0);
  311.       DoMethod(data->lpLampRed,    MUIM_Lamp_SetRGB, 0xffffffff, 0, 0);
  312.       data->ihn.ihn_Millis = 7500;
  313.       data->state = 0;
  314.       break;
  315.   }
  316.  
  317.   DoMethod(_app(obj), MUIM_Application_AddInputHandler, &data->ihn);
  318.  
  319.   return(TRUE);
  320. }
  321. ULONG ASM SAVEDS TrafficLight_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  322. {
  323.   switch (msg->MethodID)
  324.   {
  325.     case OM_NEW:                   return(TrafficLight_NEW(cl, obj, (struct opSet *) msg));
  326.  
  327.     case MUIM_Setup:               return(TrafficLight_Setup(cl, obj, msg));
  328.     case MUIM_Cleanup:             return(TrafficLight_Cleanup(cl, obj, msg));
  329.  
  330.     case MUIM_TrafficLight_Change: return(TrafficLight_Change(cl, obj));
  331.   }
  332.   return(DoSuperMethodA(cl, obj, msg));
  333. }
  334.  
  335. Object *lampbutton(ULONG id)
  336. {
  337.   char *label;
  338.   char  key;
  339.  
  340.   switch (id)
  341.   {
  342.     case MUIV_Lamp_Color_Ok:
  343.       label = "Ok";
  344.       key   = 'k';
  345.       break;
  346.     case MUIV_Lamp_Color_Warning:
  347.       label = "Warning";
  348.       key   = 'w';
  349.       break;
  350.     case MUIV_Lamp_Color_Error:
  351.       label = "Error";
  352.       key   = 'e';
  353.       break;
  354.     case MUIV_Lamp_Color_FatalError:
  355.       label = "Fatal error";
  356.       key   = 'f';
  357.       break;
  358.     case MUIV_Lamp_Color_Processing:
  359.       label = "Processing";
  360.       key   = 'p';
  361.       break;
  362.     case MUIV_Lamp_Color_LookingUp:
  363.       label = "Looking up";
  364.       key   = 'i';
  365.       break;
  366.     case MUIV_Lamp_Color_Connecting:
  367.       label = "Connecting";
  368.       key   = 'c';
  369.       break;
  370.     case MUIV_Lamp_Color_SendingData:
  371.       label = "Sending data";
  372.       key   = 'n';
  373.       break;
  374.     case MUIV_Lamp_Color_ReceivingData:
  375.       label = "Receiving data";
  376.       key   = 'r';
  377.       break;
  378.     case MUIV_Lamp_Color_LoadingData:
  379.       label = "Loading data";
  380.       key   = 'l';
  381.       break;
  382.     case MUIV_Lamp_Color_SavingData:
  383.       label = "Saving data";
  384.       key   = 's';
  385.       break;
  386.     default:   /* case MUIV_Lamp_Color_Off: */
  387.       label = "Off";
  388.       key   = 'o';
  389.       break;
  390.   }
  391.  
  392.   return(HGroup,
  393.     ButtonFrame,
  394.     MUIA_Background, MUII_ButtonBack,
  395.     MUIA_Font, MUIV_Font_Button,
  396.     MUIA_HorizWeight, 0,
  397.     MUIA_ControlChar, key,
  398.     MUIA_InputMode, MUIV_InputMode_RelVerify,
  399.     MUIA_CycleChain, TRUE,
  400.     MUIA_Group_VertSpacing, 0,
  401.     Child, LampObject,
  402.       MUIA_Lamp_Type, MUIV_Lamp_Type_Huge,
  403.       MUIA_Lamp_Color, id,
  404.     End,
  405.     Child, MUI_MakeObject(MUIO_VBar, 2),
  406.     Child, RectangleObject, End,
  407.     Child, TextObject,
  408.       MUIA_Text_SetMax, TRUE,
  409.       MUIA_Text_Contents, label,
  410.       MUIA_Text_HiChar, key,
  411.     End,
  412.     Child, RectangleObject, End,
  413.   End);
  414. }
  415. Object *button(char *label, char key)
  416. {
  417.   return(TextObject,
  418.     ButtonFrame,
  419.     MUIA_Background, MUII_ButtonBack,
  420.     MUIA_Font, MUIV_Font_Button,
  421.     MUIA_InputMode, MUIV_InputMode_RelVerify,
  422.     MUIA_Text_PreParse, "\033c",
  423.     MUIA_Text_Contents, label,
  424.     MUIA_Text_HiChar, key,
  425.     MUIA_ControlChar, key,
  426.     MUIA_CycleChain, TRUE,
  427.   End);
  428. }
  429.  
  430. int main(void)
  431. {
  432.   int                ret           = RETURN_FAIL;
  433.   static const char *txt_rgMain [] =
  434.   {
  435.     "Setting attributes",
  436.     "Just kidding",
  437.     NULL
  438.   };
  439.  
  440.   if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME, MUIMASTER_VMIN)))
  441.     goto bye;
  442.  
  443.   if (!(clDropableLamp = MUI_CreateCustomClass(NULL, MUIC_Lamp, NULL, sizeof(struct DropableLampData), DropableLamp_Dispatcher)))
  444.     goto bye;
  445.   if (!(clBlinkingLamp = MUI_CreateCustomClass(NULL, MUIC_Lamp, NULL, sizeof(struct BlinkingLampData), BlinkingLamp_Dispatcher)))
  446.     goto bye;
  447.   if (!(clTrafficLight = MUI_CreateCustomClass(NULL, MUIC_Group, NULL, sizeof(struct TrafficLightData), TrafficLight_Dispatcher)))
  448.     goto bye;
  449.  
  450.   if (!(apMain = ApplicationObject,
  451.     MUIA_Application_Title,       "Lamp-Demo",
  452.     MUIA_Application_Version,     "$VER: Lamp-Demo 1.1 (16.3.97) © by Maik \"BLiZZeR\" Schreiber",
  453.     MUIA_Application_Copyright,   "Copyright © 16-Mar-1997 by Maik Schreiber <BLiZZeR@dame.de>",
  454.     MUIA_Application_Author,      "Maik Schreiber <BLiZZeR@dame.de>",
  455.     MUIA_Application_Description, "Demonstrates Lamp.mcc's features",
  456.     MUIA_Application_Base,        "LAMPDEMO",
  457.  
  458.     SubWindow, wiMain = WindowObject,
  459.       MUIA_Window_Title, "Lamp-Demo 1.1",
  460.       MUIA_Window_Width, MUIV_Window_Width_Visible(100),
  461.       MUIA_Window_Height, MUIV_Window_Height_Visible(100),
  462.       WindowContents, VGroup,
  463.         Child, RegisterGroup(txt_rgMain),
  464.           MUIA_Register_Frame, TRUE,
  465.           MUIA_CycleChain, TRUE,
  466.           Child, VGroup,
  467.             GroupFrame,
  468.             MUIA_Background, MUII_PageBack,
  469.             Child, HGroup,
  470.               Child, VGroup,
  471.                 GroupFrameT("Lamp"),
  472.                 Child, RectangleObject, End,
  473.                 Child, HGroup,
  474.                   Child, HSpace(25),
  475.                   Child, lpLamp = DropableLampObject,
  476.                     MUIA_Lamp_Type, MUIV_Lamp_Type_Huge,
  477.                     MUIA_Lamp_Red,   0xffffffff,
  478.                     MUIA_Lamp_Green, 0,
  479.                     MUIA_Lamp_Blue,  0,
  480.                   End,
  481.                   Child, HSpace(25),
  482.                 End,
  483.                 Child, RectangleObject, End,
  484.               End,
  485.               Child, HSpace(8),
  486.               Child, VGroup,
  487.                 Child, HGroup,
  488.                   GroupFrameT("Color"),
  489.                   Child, VGroup,
  490.                     Child, MUI_MakeObject(MUIO_BarTitle, "Custom"),
  491.                     Child, caColor = ColoradjustObject,
  492.                       MUIA_Coloradjust_Red,   0xffffffff,
  493.                       MUIA_Coloradjust_Green, 0,
  494.                       MUIA_Coloradjust_Blue,  0,
  495.                     End,
  496.                   End,
  497.                   Child, MUI_MakeObject(MUIO_VBar, 6),
  498.                   Child, VGroup,
  499.                     Child, MUI_MakeObject(MUIO_BarTitle, "Preferences"),
  500.                     Child, RectangleObject, End,
  501.                     Child, ColGroup(2),
  502.                       MUIA_Group_VertSpacing, 1,
  503.                       MUIA_Group_SameWidth, TRUE,
  504.                       Child, btColorOff           = lampbutton(MUIV_Lamp_Color_Off),
  505.                       Child, btColorLookingUp     = lampbutton(MUIV_Lamp_Color_LookingUp),
  506.                       Child, btColorOk            = lampbutton(MUIV_Lamp_Color_Ok),
  507.                       Child, btColorConnecting    = lampbutton(MUIV_Lamp_Color_Connecting),
  508.                       Child, btColorWarning       = lampbutton(MUIV_Lamp_Color_Warning),
  509.                       Child, btColorSendingData   = lampbutton(MUIV_Lamp_Color_SendingData),
  510.                       Child, btColorError         = lampbutton(MUIV_Lamp_Color_Error),
  511.                       Child, btColorReceivingData = lampbutton(MUIV_Lamp_Color_ReceivingData),
  512.                       Child, btColorFatalError    = lampbutton(MUIV_Lamp_Color_FatalError),
  513.                       Child, btColorLoadingData   = lampbutton(MUIV_Lamp_Color_LoadingData),
  514.                       Child, btColorProcessing    = lampbutton(MUIV_Lamp_Color_Processing),
  515.                       Child, btColorSavingData    = lampbutton(MUIV_Lamp_Color_SavingData),
  516.                     End,
  517.                     Child, RectangleObject, End,
  518.                   End,
  519.                 End,
  520.                 Child, VSpace(8),
  521.                 Child, HGroup,
  522.                   Child, VGroup,
  523.                     GroupFrameT("Type"),
  524.                     GroupSpacing(1),
  525.                     Child, RectangleObject, End,
  526.                     Child, ColGroup(2),
  527.                       GroupSpacing(1),
  528.                       Child, btTiny   = button("Tiny",   't'),
  529.                       Child, btMedium = button("Medium", 'd'),
  530.                       Child, btSmall  = button("Small",  'm'),
  531.                       Child, btBig    = button("Big",    'b'),
  532.                     End,
  533.                     Child, btHuge = button("Huge", 'h'),
  534.                     Child, RectangleObject, End,
  535.                   End,
  536.                   Child, HSpace(8),
  537.                   Child, ColGroup(5),
  538.                     GroupFrameT("PenSpec (drag'n'drop)"),
  539.                     Child, FreeLabel("Shine:"),
  540.                     Child, pdShine      = PendisplayObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_Draggable, TRUE, End,
  541.                     Child, HSpace(8),
  542.                     Child, FreeLabel("Shadow:"),
  543.                     Child, pdShadow     = PendisplayObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_Draggable, TRUE, End,
  544.                     Child, FreeLabel("Half shine:"),
  545.                     Child, pdHalfShine  = PendisplayObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_Draggable, TRUE, End,
  546.                     Child, HSpace(8),
  547.                     Child, FreeLabel("Text:"),
  548.                     Child, pdText       = PendisplayObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_Draggable, TRUE, End,
  549.                     Child, FreeLabel("Background:"),
  550.                     Child, pdBackground = PendisplayObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_Draggable, TRUE, End,
  551.                     Child, HSpace(8),
  552.                     Child, FreeLabel("Fill:"),
  553.                     Child, pdFill       = PendisplayObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_Draggable, TRUE, End,
  554.                     Child, FreeLabel("Half shadow:"),
  555.                     Child, pdHalfShadow = PendisplayObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_Draggable, TRUE, End,
  556.                     Child, HSpace(8),
  557.                     Child, FreeLabel("Mark:"),
  558.                     Child, pdMark       = PendisplayObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_Draggable, TRUE, End,
  559.                   End,
  560.                 End,
  561.               End,
  562.             End,
  563.             Child, VSpace(8),
  564.             Child, HGroup,
  565.               Child, Label("Current lamp color type:"),
  566.               Child, txColorType = TextObject,
  567.                 TextFrame,
  568.                 MUIA_Background, MUII_TextBack,
  569.                 MUIA_Text_Contents, "direct color value",
  570.               End,
  571.             End,
  572.           End,
  573.           Child, HGroup,
  574.             GroupFrame,
  575.             MUIA_Background, MUII_PageBack,
  576.             Child, RectangleObject, End,
  577.             Child, VGroup,
  578.               Child, RectangleObject, End,
  579.               Child, MUI_MakeObject(MUIO_BarTitle, "Blinking lamps"),
  580.               Child, HGroup,
  581.                 Child, RectangleObject, End,
  582.                 Child, ColGroup(3),
  583.                   GroupSpacing(1),
  584.                   Child, BlinkingLampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Big, End,
  585.                   Child, BlinkingLampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Big, End,
  586.                   Child, BlinkingLampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Big, End,
  587.                   Child, BlinkingLampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Big, End,
  588.                   Child, BlinkingLampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Big, End,
  589.                   Child, BlinkingLampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Big, End,
  590.                   Child, BlinkingLampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Big, End,
  591.                   Child, BlinkingLampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Big, End,
  592.                   Child, BlinkingLampObject, MUIA_Lamp_Type, MUIV_Lamp_Type_Big, End,
  593.                 End,
  594.                 Child, RectangleObject, End,
  595.               End,
  596.               Child, VSpace(8),
  597.               Child, MUI_MakeObject(MUIO_BarTitle, "Traffic light"),
  598.               Child, HGroup,
  599.                 Child, RectangleObject, End,
  600.                 Child, TrafficLightObject, End,
  601.                 Child, RectangleObject, End,
  602.               End,
  603.               Child, RectangleObject, End,
  604.             End,
  605.             Child, RectangleObject, End,
  606.           End,
  607.         End,
  608.       End,
  609.     End,
  610.   End))
  611.     goto bye;
  612.  
  613.   /* Damn *NASTY* MUI bug! */
  614.   set(pdShine,      MUIA_Dropable, FALSE);
  615.   set(pdHalfShine,  MUIA_Dropable, FALSE);
  616.   set(pdBackground, MUIA_Dropable, FALSE);
  617.   set(pdHalfShadow, MUIA_Dropable, FALSE);
  618.   set(pdShadow,     MUIA_Dropable, FALSE);
  619.   set(pdText,       MUIA_Dropable, FALSE);
  620.   set(pdFill,       MUIA_Dropable, FALSE);
  621.   set(pdMark,       MUIA_Dropable, FALSE);
  622.   /* end of annoying bug handling */
  623.  
  624.   DoMethod(pdShine,      MUIM_Pendisplay_SetMUIPen, MPEN_SHINE);
  625.   DoMethod(pdHalfShine,  MUIM_Pendisplay_SetMUIPen, MPEN_HALFSHINE);
  626.   DoMethod(pdBackground, MUIM_Pendisplay_SetMUIPen, MPEN_BACKGROUND);
  627.   DoMethod(pdHalfShadow, MUIM_Pendisplay_SetMUIPen, MPEN_HALFSHADOW);
  628.   DoMethod(pdShadow,     MUIM_Pendisplay_SetMUIPen, MPEN_SHADOW);
  629.   DoMethod(pdText,       MUIM_Pendisplay_SetMUIPen, MPEN_TEXT);
  630.   DoMethod(pdFill,       MUIM_Pendisplay_SetMUIPen, MPEN_FILL);
  631.   DoMethod(pdMark,       MUIM_Pendisplay_SetMUIPen, MPEN_MARK);
  632.  
  633.   DoMethod(lpLamp, MUIM_Notify, MUIA_Lamp_ColorType, MUIV_EveryTime, apMain, 2, MUIM_Application_ReturnID, GUI_LAMP_COLORTYPE);
  634.  
  635.   DoMethod(caColor, MUIM_Notify, MUIA_Coloradjust_RGB, MUIV_EveryTime, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_TriggerValue);
  636.  
  637.   DoMethod(btColorOff,           MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_Off);
  638.   DoMethod(btColorOk,            MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_Ok);
  639.   DoMethod(btColorWarning,       MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_Warning);
  640.   DoMethod(btColorError,         MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_Error);
  641.   DoMethod(btColorFatalError,    MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_FatalError);
  642.   DoMethod(btColorProcessing,    MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_Processing);
  643.   DoMethod(btColorLookingUp,     MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_LookingUp);
  644.   DoMethod(btColorConnecting,    MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_Connecting);
  645.   DoMethod(btColorSendingData,   MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_SendingData);
  646.   DoMethod(btColorReceivingData, MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_ReceivingData);
  647.   DoMethod(btColorLoadingData,   MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_LoadingData);
  648.   DoMethod(btColorSavingData,    MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Color, MUIV_Lamp_Color_SavingData);
  649.  
  650.   DoMethod(btTiny,   MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Type, MUIV_Lamp_Type_Tiny);
  651.   DoMethod(btSmall,  MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Type, MUIV_Lamp_Type_Small);
  652.   DoMethod(btMedium, MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Type, MUIV_Lamp_Type_Medium);
  653.   DoMethod(btBig,    MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Type, MUIV_Lamp_Type_Big);
  654.   DoMethod(btHuge,   MUIM_Notify, MUIA_Pressed, FALSE, lpLamp, 3, MUIM_Set, MUIA_Lamp_Type, MUIV_Lamp_Type_Huge);
  655.  
  656.   DoMethod(wiMain, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, apMain, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
  657.  
  658.   ret = RETURN_ERROR;
  659.  
  660.   {
  661.     ULONG open;
  662.  
  663.     set(wiMain, MUIA_Window_Open, TRUE);
  664.     get(wiMain, MUIA_Window_Open, &open);
  665.     if (!open)
  666.       goto bye;
  667.   }
  668.  
  669.   {
  670.     ULONG sigs    = 0UL;
  671.     BOOL  running = TRUE;
  672.  
  673.     while (running)
  674.     {
  675.       switch (DoMethod(apMain, MUIM_Application_NewInput, &sigs))
  676.       {
  677.         case MUIV_Application_ReturnID_Quit:
  678.           running = FALSE;
  679.           break;
  680.         case GUI_LAMP_COLORTYPE:
  681.           {
  682.             ULONG type;
  683.  
  684.             get(lpLamp, MUIA_Lamp_ColorType, &type);
  685.             switch (type)
  686.             {
  687.               case MUIV_Lamp_ColorType_UserDefined:
  688.                 set(txColorType, MUIA_Text_Contents, "user preferences");
  689.                 break;
  690.               case MUIV_Lamp_ColorType_Color:
  691.                 set(txColorType, MUIA_Text_Contents, "direct color value");
  692.                 break;
  693.               case MUIV_Lamp_ColorType_PenSpec:
  694.                 set(txColorType, MUIA_Text_Contents, "direct PenSpec definition");
  695.                 break;
  696.             }
  697.           }
  698.           break;
  699.       }
  700.  
  701.       if (running && sigs)
  702.       {
  703.         sigs = Wait(sigs | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_E | SIGBREAKF_CTRL_F);
  704.  
  705.         if (sigs & SIGBREAKF_CTRL_C)
  706.           running = FALSE;
  707.         if (sigs & SIGBREAKF_CTRL_F)
  708.           set(apMain, MUIA_Application_Iconified, FALSE);
  709.         else if (sigs & SIGBREAKF_CTRL_E)
  710.           set(apMain, MUIA_Application_Iconified, TRUE);
  711.       }
  712.     }
  713.   }
  714.  
  715.   ret = RETURN_OK;
  716.  
  717.   bye:
  718.   if (apMain)         MUI_DisposeObject(apMain);
  719.   if (clTrafficLight) MUI_DeleteCustomClass(clTrafficLight);
  720.   if (clBlinkingLamp) MUI_DeleteCustomClass(clBlinkingLamp);
  721.   if (clDropableLamp) MUI_DeleteCustomClass(clDropableLamp);
  722.   if (MUIMasterBase)  CloseLibrary(MUIMasterBase);
  723.   exit(ret);
  724. }
  725.  
  726.